package com.yn.xgame.logic.util;

import java.text.SimpleDateFormat;  
import java.util.ArrayList;  
import java.util.Calendar;  
import java.util.Date;  
import java.util.HashMap;  
import java.util.List;  
import java.util.Map;  
import java.text.ParseException;
  
public class DateUtil {  
	 private static String ymdhmss = "yyyy-MM-dd HH:mm:ss:SSS";
	 private static String ymdhms = "yyyy-MM-dd HH:mm:ss";    
     private static String ymd = "yyyy-MM-dd";    
     public static ThreadLocal<SimpleDateFormat> ymdSDF = new ThreadLocal<SimpleDateFormat>() {   
    	 @Override
    	 protected SimpleDateFormat initialValue() {
    		 return new SimpleDateFormat(ymd);
    	 }
     };
     private static String year = "yyyy";    
     private static String month = "MM";    
     private static String day = "dd";
     
     public static ThreadLocal<SimpleDateFormat> yyyyMMddHHmmssSS = new ThreadLocal<SimpleDateFormat>() {
    	 @Override
    	 protected SimpleDateFormat initialValue() {
    		 return new SimpleDateFormat(ymdhmss);
    	 }
     };
     public static ThreadLocal<SimpleDateFormat> yyyyMMddHHmmss = new ThreadLocal<SimpleDateFormat>() {
    	 @Override
    	 protected SimpleDateFormat initialValue() {
    		 return new SimpleDateFormat(ymdhms);
    	 }
     };
     public static ThreadLocal<SimpleDateFormat> yearSDF = new ThreadLocal<SimpleDateFormat>() {
    	 @Override
    	 protected SimpleDateFormat initialValue() {
    		 return new SimpleDateFormat(year);
    	 }
     };
     public static ThreadLocal<SimpleDateFormat> monthSDF = new ThreadLocal<SimpleDateFormat>() {
    	 @Override
    	 protected SimpleDateFormat initialValue() {
    		 return new SimpleDateFormat(month);
    	 }
     };
     public static ThreadLocal<SimpleDateFormat> daySDF = new ThreadLocal<SimpleDateFormat>() {
    	 @Override
    	 protected SimpleDateFormat initialValue() {
    		 return new SimpleDateFormat(day);
    	 }
     };
     public static ThreadLocal<SimpleDateFormat> yyyyMMddHHmm = new ThreadLocal<SimpleDateFormat>() {
    	 @Override
    	 protected SimpleDateFormat initialValue() {
    		 return new SimpleDateFormat("yyyy-MM-dd HH:mm");
    	 }
     };  
     public static ThreadLocal<SimpleDateFormat> yyyyMMdd = new ThreadLocal<SimpleDateFormat>() {
    	 @Override
    	 protected SimpleDateFormat initialValue() {
    		 return new SimpleDateFormat("yyyy-MM-dd");
    	 }
     };
     public static ThreadLocal<SimpleDateFormat> yyyyMMddHH_NOT_ = new ThreadLocal<SimpleDateFormat>() {
    	 @Override
    	 protected SimpleDateFormat initialValue() {
    		 return new SimpleDateFormat("yyyyMMdd");
    	 }
     };
     public static ThreadLocal<SimpleDateFormat> yyyyMMddHHmmss_NOT_ = new ThreadLocal<SimpleDateFormat>() {
    	 @Override
    	 protected SimpleDateFormat initialValue() {
    		 return new SimpleDateFormat("yyyyMMddHHmmss");
    	 }
     };
      
     
     public static long DATEMM = 86400L;    
     
     /**
      * 判断两个long型时间是否在同一天
      * 
      * @param date1
      * @param date2
      * @return
      */
     public static boolean isSameDay(long date1, long date2){
    	 /*Calendar cal1=Calendar.getInstance();
    	 Calendar cal2=Calendar.getInstance();
    	 cal1.setTimeInMillis(date1);
    	 cal2.setTimeInMillis(date2);
    	 
    	 cal1.set(Calendar.HOUR_OF_DAY, 0);
    	 cal1.set(Calendar.MINUTE, 0);
    	 cal1.set(Calendar.SECOND, 0);
    	 cal1.set(Calendar.MILLISECOND, 0);
    	 
    	 cal2.set(Calendar.HOUR_OF_DAY, 0);
    	 cal2.set(Calendar.MINUTE, 0);
    	 cal2.set(Calendar.SECOND, 0);
    	 cal2.set(Calendar.MILLISECOND, 0);
    	 
    	 if(cal1.getTimeInMillis()==cal2.getTimeInMillis()){
    		 return true;
    	 }*/
    	 long millis=24;
    	 if(date1/millis==date2/millis){
    		 return true;
    	 }
    	 return false;
     }
     
     /**
      * 判断long型时间是否是当天时间
      * 
      * @param date
      * @return
      */
     public static boolean istoday(long date) {
    	 Calendar today=Calendar.getInstance();
    	 today.set(Calendar.HOUR_OF_DAY, 0);
    	 today.set(Calendar.MINUTE, 0);
    	 today.set(Calendar.SECOND, 0);
    	 today.set(Calendar.MILLISECOND, 0);
    	 
    	 long start=today.getTimeInMillis();
    	 long sub=date-start;
    	 if(sub>=0&&sub<24*60*60*1000){
    		 return true;
    	 }
    	 return false;
     }
     
     /**  
      * 获得当前时间  
      * 格式：2014-12-02 10:38:53  
      * @return String  
      */  
     public static String getCurrentTime() {    
         return yyyyMMddHHmmss.get().format(new Date());    
     }
     /**  
      *获取当前的年、月、日  
      * @return String  
      */  
     public static String getCurrentYear() {    
         return yearSDF.get().format(new Date());    
     }   
     public static String getCurrentMonth() {    
         return monthSDF.get().format(new Date());    
     }   
     public static String getCurrentDay() {    
         return daySDF.get().format(new Date());    
     }    
     /**  
      * 获取年月日 也就是当前时间  
      * 格式：2014-12-02  
      * @return String  
      */  
     public static String getCurrentymd() {    
         return ymdSDF.get().format(new Date());    
     }  
     /**  
      * 获取今天的日期  
      * 格式：20141202  
      * @return String  
      */  
     public static String getTodateString() {    
         String str = yyyyMMddHH_NOT_.get().format(new Date());    
         return str;    
     }  
     /**    
      * 把long型日期转String ；---OK    
      *     
      * @param date    
      *            long型日期；    
      * @param format    
      *            日期格式；    
      * @return    
      */    
     public static String longToString(long date, String format) {    
         SimpleDateFormat sdf = new SimpleDateFormat(format);    
         // 前面的lSysTime是秒数，先乘1000得到毫秒数，再转为java.util.Date类型    
         java.util.Date dt2 = new Date(date * 1000L);    
         String sDateTime = sdf.format(dt2); // 得到精确到秒的表示：08/31/2006 21:08:00    
         return sDateTime;    
     }
     /**
      * 把long类型日期转换成yyyyMMddHHmmss_NOT_时间格式字符串
      * 
      * @param millis
      * @return
      */
     public static String millisToString(long millis) {
    	 return yyyyMMddHHmmss_NOT_.get().format(new Date(millis));
     }
     
     /**    
      * 获得今天零点    
      *     
      * @return Date  
      */    
     public static Date getTodayZeroHour() {    
         Calendar cal = Calendar.getInstance();    
         cal.set(Calendar.SECOND, 0);    
         cal.set(Calendar.MINUTE, 0);    
         cal.set(Calendar.HOUR, 0);    
         return cal.getTime();    
     }    
     /**    
      * String To Date ---OK    
      *     
      * @param date    
      *            待转换的字符串型日期；    
      * @param format    
      *            转化的日期格式    
      * @return 返回该字符串的日期型数据；    
      */    
     public static Date stringToDate(String date, String format) {    
         SimpleDateFormat sdf = new SimpleDateFormat(format);    
         try {    
             return sdf.parse(date);    
         } catch (ParseException e) {    
             return null;    
         }    
     }
     
     public static Date ymdhmsToDate(String date) throws ParseException {
    	 Date rst = null;
    	 rst = yyyyMMddHHmmss.get().parse(date);
    	 return rst;
     }
     
     /**    
      *     
      * 求某一个时间向前多少秒的时间(currentTimeToBefer)---OK    
      *     
      * @param givedTime    
      *            给定的时间    
      * @param interval    
      *            间隔时间的毫秒数；计算方式 ：n(天)*24(小时)*60(分钟)*60(秒)(类型)    
      * @param format_Date_Sign    
      *            输出日期的格式；如yyyy-MM-dd、yyyyMMdd等；    
      */    
     public static String givedTimeToBefer(String givedTime, long interval,    
             String format_Date_Sign) {    
         String tomorrow = null;    
         try {    
             SimpleDateFormat sdf = new SimpleDateFormat(format_Date_Sign);    
             Date gDate = sdf.parse(givedTime);    
             long current = gDate.getTime(); // 将Calendar表示的时间转换成毫秒    
             long beforeOrAfter = current - interval * 1000L; // 将Calendar表示的时间转换成毫秒    
             Date date = new Date(beforeOrAfter); // 用timeTwo作参数构造date2    
             tomorrow = new SimpleDateFormat(format_Date_Sign).format(date);    
         } catch (ParseException e) {    
             e.printStackTrace();    
         }    
         return tomorrow;    
     }    
     /**    
      * 把String 日期转换成long型日期；---OK    
      *     
      * @param date    
      *            String 型日期；    
      * @param format    
      *            日期格式；    
      * @return    
      */    
     public static long stringToLong(String date, String format) {    
         SimpleDateFormat sdf = new SimpleDateFormat(format);    
         Date dt2 = null;    
         long lTime = 0;    
         try {    
             dt2 = sdf.parse(date);    
             // 继续转换得到秒数的long型    
             lTime = dt2.getTime() / 1000;    
         } catch (ParseException e) {    
             e.printStackTrace();    
         }    
     
         return lTime;    
     }
     
     
     /**    
      * 得到二个日期间的间隔日期；    
      *     
      * @param endTime    
      *            结束时间    
      * @param beginTime    
      *            开始时间    
      * @param isEndTime    
      *            是否包含结束日期；    
      * @return    
      */    
     public static Map<String, String> getTwoDay(String endTime,    
             String beginTime, boolean isEndTime) {    
         Map<String, String> result = new HashMap<String, String>();    
         if ((endTime == null || endTime.equals("") || (beginTime == null || beginTime    
                 .equals(""))))    
             return null;    
         try {    
             java.util.Date date = ymdSDF.get().parse(endTime);    
             endTime = ymdSDF.get().format(date);    
             java.util.Date mydate = ymdSDF.get().parse(beginTime);    
             long day = (date.getTime() - mydate.getTime())    
                     / (24 * 60 * 60 * 1000);    
             result = getDate(endTime, Integer.parseInt(day + ""), isEndTime);    
         } catch (Exception e) {    
         }    
         return result;    
     }    
     
     /**    
      * 得到二个日期间的间隔日期；    
      *     
      * @param endTime    
      *            结束时间    
      * @param beginTime    
      *            开始时间    
      * @param isEndTime    
      *            是否包含结束日期；    
      * @return    
      */    
     public static Integer getTwoDayInterval(String endTime, String beginTime,    
             boolean isEndTime) {    
         if ((endTime == null || endTime.equals("") || (beginTime == null || beginTime    
                 .equals(""))))    
             return 0;    
         long day = 0l;    
         try {    
             java.util.Date date = ymdSDF.get().parse(endTime);    
             endTime = ymdSDF.get().format(date);    
             java.util.Date mydate = ymdSDF.get().parse(beginTime);    
             day = (date.getTime() - mydate.getTime()) / (24 * 60 * 60 * 1000);    
         } catch (Exception e) {    
             return 0 ;    
         }    
         return Integer.parseInt(day + "");    
     }    
     
     /**    
      * 根据结束时间以及间隔差值，求符合要求的日期集合；    
      *     
      * @param endTime    
      * @param interval    
      * @param isEndTime    
      * @return    
      */    
     public static Map<String, String> getDate(String endTime, Integer interval,    
             boolean isEndTime) {    
         Map<String, String> result = new HashMap<String, String>();    
         if (interval == 0 || isEndTime) {    
             if (isEndTime)    
                 result.put(endTime, endTime);    
         }    
         if (interval > 0) {    
             int begin = 0;    
             for (int i = begin; i < interval; i++) {    
                 endTime = givedTimeToBefer(endTime, DATEMM, ymd);    
                 result.put(endTime, endTime);    
             }    
         }    
         return result;    
     }
  
    /** 
     * 获取SimpleDateFormat 
     * @param parttern 日期格式 
     * @return SimpleDateFormat对象 
     * @throws RuntimeException 异常：非法日期格式 
     */  
    private static SimpleDateFormat getDateFormat(String parttern) throws RuntimeException {  
        return new SimpleDateFormat(parttern);  
    }  
  
    /** 
     * 获取日期中的某数值。如获取月份 
     * @param date 日期 
     * @param dateType 日期格式 
     * @return 数值 
     */  
    private static int getInteger(Date date, int dateType) {  
        Calendar calendar = Calendar.getInstance();  
        calendar.setTime(date);  
        return calendar.get(dateType);  
    }  
      
    /** 
     * 增加日期中某类型的某数值。如增加日期 
     * @param date 日期字符串 
     * @param dateType 类型 
     * @param amount 数值 
     * @return 计算后日期字符串 
     */  
    private static String addInteger(String date, int dateType, int amount) {  
        String dateString = null;  
        DateStyle dateStyle = getDateStyle(date);  
        if (dateStyle != null) {  
            Date myDate = StringToDate(date, dateStyle);  
            myDate = addInteger(myDate, dateType, amount);  
            dateString = DateToString(myDate, dateStyle);  
        }  
        return dateString;  
    }  
      
    /** 
     * 增加日期中某类型的某数值。如增加日期 
     * @param date 日期 
     * @param dateType 类型 
     * @param amount 数值 
     * @return 计算后日期 
     */  
    private static Date addInteger(Date date, int dateType, int amount) {  
        Date myDate = null;  
        if (date != null) {  
            Calendar calendar = Calendar.getInstance();  
            calendar.setTime(date);  
            calendar.add(dateType, amount);  
            myDate = calendar.getTime();  
        }  
        return myDate;  
    }  
  
    /** 
     * 获取精确的日期 
     * @param timestamps 时间long集合 
     * @return 日期 
     */  
    private static Date getAccurateDate(List<Long> timestamps) {  
        Date date = null;  
        long timestamp = 0;  
        Map<Long, long[]> map = new HashMap<Long, long[]>();  
        List<Long> absoluteValues = new ArrayList<Long>();  
  
        if (timestamps != null && timestamps.size() > 0) {  
            if (timestamps.size() > 1) {  
                for (int i = 0; i < timestamps.size(); i++) {  
                    for (int j = i + 1; j < timestamps.size(); j++) {  
                        long absoluteValue = Math.abs(timestamps.get(i) - timestamps.get(j));  
                        absoluteValues.add(absoluteValue);  
                        long[] timestampTmp = { timestamps.get(i), timestamps.get(j) };  
                        map.put(absoluteValue, timestampTmp);  
                    }  
                }  
  
                // 有可能有相等的情况。如2012-11和2012-11-01。时间戳是相等的  
                long minAbsoluteValue = -1;  
                if (!absoluteValues.isEmpty()) {  
                    // 如果timestamps的size为2，这是差值只有一个，因此要给默认值  
                    minAbsoluteValue = absoluteValues.get(0);  
                }  
                for (int i = 0; i < absoluteValues.size(); i++) {  
                    for (int j = i + 1; j < absoluteValues.size(); j++) {  
                        if (absoluteValues.get(i) > absoluteValues.get(j)) {  
                            minAbsoluteValue = absoluteValues.get(j);  
                        } else {  
                            minAbsoluteValue = absoluteValues.get(i);  
                        }  
                    }  
                }  
  
                if (minAbsoluteValue != -1) {  
                    long[] timestampsLastTmp = map.get(minAbsoluteValue);  
                    if (absoluteValues.size() > 1) {  
                        timestamp = Math.max(timestampsLastTmp[0], timestampsLastTmp[1]);  
                    } else if (absoluteValues.size() == 1) {  
                        // 当timestamps的size为2，需要与当前时间作为参照  
                        long dateOne = timestampsLastTmp[0];  
                        long dateTwo = timestampsLastTmp[1];  
                        if ((Math.abs(dateOne - dateTwo)) < 100000000000L) {  
                            timestamp = Math.max(timestampsLastTmp[0], timestampsLastTmp[1]);  
                        } else {  
                            long now = new Date().getTime();  
                            if (Math.abs(dateOne - now) <= Math.abs(dateTwo - now)) {  
                                timestamp = dateOne;  
                            } else {  
                                timestamp = dateTwo;  
                            }  
                        }  
                    }  
                }  
            } else {  
                timestamp = timestamps.get(0);  
            }  
        }  
  
        if (timestamp != 0) {  
            date = new Date(timestamp);  
        }  
        return date;  
    }  
  
    /** 
     * 判断字符串是否为日期字符串 
     * @param date 日期字符串 
     * @return true or false 
     */  
    public static boolean isDate(String date) {  
        boolean isDate = false;  
        if (date != null) {  
            if (StringToDate(date) != null) {  
                isDate = true;  
            }  
        }  
        return isDate;  
    }  
  
    /** 
     * 获取日期字符串的日期风格。失敗返回null。 
     * @param date 日期字符串 
     * @return 日期风格 
     */  
    public static DateStyle getDateStyle(String date) {  
        DateStyle dateStyle = null;  
        Map<Long, DateStyle> map = new HashMap<Long, DateStyle>();  
        List<Long> timestamps = new ArrayList<Long>();  
        for (DateStyle style : DateStyle.values()) {  
            Date dateTmp = StringToDate(date, style.getValue());  
            if (dateTmp != null) {  
                timestamps.add(dateTmp.getTime());  
                map.put(dateTmp.getTime(), style);  
            }  
        }  
        dateStyle = map.get(getAccurateDate(timestamps).getTime());  
        return dateStyle;  
    }  
  
    /** 
     * 将日期字符串转化为日期。失败返回null。 
     * @param date 日期字符串 
     * @return 日期 
     */  
    public static Date StringToDate(String date) {  
        DateStyle dateStyle = null;  
        return StringToDate(date, dateStyle);  
    }  
  
    /** 
     * 将日期字符串转化为日期。失败返回null。 
     * @param date 日期字符串 
     * @param parttern 日期格式 
     * @return 日期 
     */  
    public static Date StringToDate(String date, String parttern) {  
        Date myDate = null;  
        if (date != null) {  
            try {  
                myDate = getDateFormat(parttern).parse(date);  
            } catch (Exception e) {  
            }  
        }  
        return myDate;  
    }  
  
    /** 
     * 将日期字符串转化为日期。失败返回null。 
     * @param date 日期字符串 
     * @param dateStyle 日期风格 
     * @return 日期 
     */  
    public static Date StringToDate(String date, DateStyle dateStyle) {  
        Date myDate = null;  
        if (dateStyle == null) {  
            List<Long> timestamps = new ArrayList<Long>();  
            for (DateStyle style : DateStyle.values()) {  
                Date dateTmp = StringToDate(date, style.getValue());  
                if (dateTmp != null) {  
                    timestamps.add(dateTmp.getTime());  
                }  
            }  
            myDate = getAccurateDate(timestamps);  
        } else {  
            myDate = StringToDate(date, dateStyle.getValue());  
        }  
        return myDate;  
    }  
  
    /** 
     * 将日期转化为日期字符串。失败返回null。 
     * @param date 日期 
     * @param parttern 日期格式 
     * @return 日期字符串 
     */  
    public static String DateToString(Date date, String parttern) {  
        String dateString = null;  
        if (date != null) {  
            try {  
                dateString = getDateFormat(parttern).format(date);  
            } catch (Exception e) {  
            }  
        }  
        return dateString;  
    }  
  
    /** 
     * 将日期转化为日期字符串。失败返回null。 
     * @param date 日期 
     * @param dateStyle 日期风格 
     * @return 日期字符串 
     */  
    public static String DateToString(Date date, DateStyle dateStyle) {  
        String dateString = null;  
        if (dateStyle != null) {  
            dateString = DateToString(date, dateStyle.getValue());  
        }  
        return dateString;  
    }  
  
    /** 
     * 将日期字符串转化为另一日期字符串。失败返回null。 
     * @param date 旧日期字符串 
     * @param parttern 新日期格式 
     * @return 新日期字符串 
     */  
    public static String StringToString(String date, String parttern) {  
        return StringToString(date, null, parttern);  
    }  
  
    /** 
     * 将日期字符串转化为另一日期字符串。失败返回null。 
     * @param date 旧日期字符串 
     * @param dateStyle 新日期风格 
     * @return 新日期字符串 
     */  
    public static String StringToString(String date, DateStyle dateStyle) {  
        return StringToString(date, null, dateStyle);  
    }  
  
    /** 
     * 将日期字符串转化为另一日期字符串。失败返回null。 
     * @param date 旧日期字符串 
     * @param olddParttern 旧日期格式 
     * @param newParttern 新日期格式 
     * @return 新日期字符串 
     */  
    public static String StringToString(String date, String olddParttern, String newParttern) {  
        String dateString = null;  
        if (olddParttern == null) {  
            DateStyle style = getDateStyle(date);  
            if (style != null) {  
                Date myDate = StringToDate(date, style.getValue());  
                dateString = DateToString(myDate, newParttern);  
            }  
        } else {  
            Date myDate = StringToDate(date, olddParttern);  
            dateString = DateToString(myDate, newParttern);  
        }  
        return dateString;  
    }  
  
    /** 
     * 将日期字符串转化为另一日期字符串。失败返回null。 
     * @param date 旧日期字符串 
     * @param olddDteStyle 旧日期风格 
     * @param newDateStyle 新日期风格 
     * @return 新日期字符串 
     */  
    public static String StringToString(String date, DateStyle olddDteStyle, DateStyle newDateStyle) {  
        String dateString = null;  
        if (olddDteStyle == null) {  
            DateStyle style = getDateStyle(date);  
            dateString = StringToString(date, style.getValue(), newDateStyle.getValue());  
        } else {  
            dateString = StringToString(date, olddDteStyle.getValue(), newDateStyle.getValue());  
        }  
        return dateString;  
    }  
  
    /** 
     * 增加日期的年份。失败返回null。 
     * @param date 日期 
     * @param yearAmount 增加数量。可为负数 
     * @return 增加年份后的日期字符串 
     */  
    public static String addYear(String date, int yearAmount) {  
        return addInteger(date, Calendar.YEAR, yearAmount);  
    }  
      
    /** 
     * 增加日期的年份。失败返回null。 
     * @param date 日期 
     * @param yearAmount 增加数量。可为负数 
     * @return 增加年份后的日期 
     */  
    public static Date addYear(Date date, int yearAmount) {  
        return addInteger(date, Calendar.YEAR, yearAmount);  
    }  
      
    /** 
     * 增加日期的月份。失败返回null。 
     * @param date 日期 
     * @param yearAmount 增加数量。可为负数 
     * @return 增加月份后的日期字符串 
     */  
    public static String addMonth(String date, int yearAmount) {  
        return addInteger(date, Calendar.MONTH, yearAmount);  
    }  
      
    /** 
     * 增加日期的月份。失败返回null。 
     * @param date 日期 
     * @param yearAmount 增加数量。可为负数 
     * @return 增加月份后的日期 
     */  
    public static Date addMonth(Date date, int yearAmount) {  
        return addInteger(date, Calendar.MONTH, yearAmount);  
    }  
      
    /** 
     * 增加日期的天数。失败返回null。 
     * @param date 日期字符串 
     * @param dayAmount 增加数量。可为负数 
     * @return 增加天数后的日期字符串 
     */  
    public static String addDay(String date, int dayAmount) {  
        return addInteger(date, Calendar.DATE, dayAmount);  
    }  
  
    /** 
     * 增加日期的天数。失败返回null。 
     * @param date 日期 
     * @param dayAmount 增加数量。可为负数 
     * @return 增加天数后的日期 
     */  
    public static Date addDay(Date date, int dayAmount) {  
        return addInteger(date, Calendar.DATE, dayAmount);  
    }  
      
    /** 
     * 增加日期的小时。失败返回null。 
     * @param date 日期字符串 
     * @param dayAmount 增加数量。可为负数 
     * @return 增加小时后的日期字符串 
     */  
    public static String addHour(String date, int hourAmount) {  
        return addInteger(date, Calendar.HOUR_OF_DAY, hourAmount);  
    }  
  
    /** 
     * 增加日期的小时。失败返回null。 
     * @param date 日期 
     * @param dayAmount 增加数量。可为负数 
     * @return 增加小时后的日期 
     */  
    public static Date addHour(Date date, int hourAmount) {  
        return addInteger(date, Calendar.HOUR_OF_DAY, hourAmount);  
    }  
      
    /** 
     * 增加日期的分钟。失败返回null。 
     * @param date 日期字符串 
     * @param dayAmount 增加数量。可为负数 
     * @return 增加分钟后的日期字符串 
     */  
    public static String addMinute(String date, int hourAmount) {  
        return addInteger(date, Calendar.MINUTE, hourAmount);  
    }  
  
    /** 
     * 增加日期的分钟。失败返回null。 
     * @param date 日期 
     * @param dayAmount 增加数量。可为负数 
     * @return 增加分钟后的日期 
     */  
    public static Date addMinute(Date date, int hourAmount) {  
        return addInteger(date, Calendar.MINUTE, hourAmount);  
    }  
      
    /** 
     * 增加日期的秒钟。失败返回null。 
     * @param date 日期字符串 
     * @param dayAmount 增加数量。可为负数 
     * @return 增加秒钟后的日期字符串 
     */  
    public static String addSecond(String date, int hourAmount) {  
        return addInteger(date, Calendar.SECOND, hourAmount);  
    }  
  
    /** 
     * 增加日期的秒钟。失败返回null。 
     * @param date 日期 
     * @param dayAmount 增加数量。可为负数 
     * @return 增加秒钟后的日期 
     */  
    public static Date addSecond(Date date, int hourAmount) {  
        return addInteger(date, Calendar.SECOND, hourAmount);  
    }  
  
    /** 
     * 获取日期的年份。失败返回0。 
     * @param date 日期字符串 
     * @return 年份 
     */  
    public static int getYear(String date) {  
        return getYear(StringToDate(date));  
    }  
  
    /** 
     * 获取日期的年份。失败返回0。 
     * @param date 日期 
     * @return 年份 
     */  
    public static int getYear(Date date) {  
        return getInteger(date, Calendar.YEAR);  
    }  
  
    /** 
     * 获取日期的月份。失败返回0。 
     * @param date 日期字符串 
     * @return 月份 
     */  
    public static int getMonth(String date) {  
        return getMonth(StringToDate(date));  
    }  
  
    /** 
     * 获取日期的月份。失败返回0。 
     * @param date 日期 
     * @return 月份 
     */  
    public static int getMonth(Date date) {  
        return getInteger(date, Calendar.MONTH);  
    }  
  
    /** 
     * 获取日期的天数。失败返回0。 
     * @param date 日期字符串 
     * @return 天 
     */  
    public static int getDay(String date) {  
        return getDay(StringToDate(date));  
    }  
  
    /** 
     * 获取日期的天数。失败返回0。 
     * @param date 日期 
     * @return 天 
     */  
    public static int getDay(Date date) {  
        return getInteger(date, Calendar.DATE);  
    }  
      
    /** 
     * 获取日期的小时。失败返回0。 
     * @param date 日期字符串 
     * @return 小时 
     */  
    public static int getHour(String date) {  
        return getHour(StringToDate(date));  
    }  
  
    /** 
     * 获取日期的小时。失败返回0。 
     * @param date 日期 
     * @return 小时 
     */  
    public static int getHour(Date date) {  
        return getInteger(date, Calendar.HOUR_OF_DAY);  
    }  
      
    /** 
     * 获取日期的分钟。失败返回0。 
     * @param date 日期字符串 
     * @return 分钟 
     */  
    public static int getMinute(String date) {  
        return getMinute(StringToDate(date));  
    }  
  
    /** 
     * 获取日期的分钟。失败返回0。 
     * @param date 日期 
     * @return 分钟 
     */  
    public static int getMinute(Date date) {  
        return getInteger(date, Calendar.MINUTE);  
    }  
      
    /** 
     * 获取日期的秒钟。失败返回0。 
     * @param date 日期字符串 
     * @return 秒钟 
     */  
    public static int getSecond(String date) {  
        return getSecond(StringToDate(date));  
    }  
  
    /** 
     * 获取日期的秒钟。失败返回0。 
     * @param date 日期 
     * @return 秒钟 
     */  
    public static int getSecond(Date date) {  
        return getInteger(date, Calendar.SECOND);  
    }  
  
    /** 
     * 获取日期 。默认yyyy-MM-dd格式。失败返回null。 
     * @param date 日期字符串 
     * @return 日期 
     */  
    public static String getDate(String date) {  
        return StringToString(date, DateStyle.YYYY_MM_DD);  
    }  
  
    /** 
     * 获取日期。默认yyyy-MM-dd格式。失败返回null。 
     * @param date 日期 
     * @return 日期 
     */  
    public static String getDate(Date date) {  
        return DateToString(date, DateStyle.YYYY_MM_DD);  
    }  
  
    /** 
     * 获取日期的时间。默认HH:mm:ss格式。失败返回null。 
     * @param date 日期字符串 
     * @return 时间 
     */  
    public static String getTime(String date) {  
        return StringToString(date, DateStyle.HH_MM_SS);  
    }  
  
    /** 
     * 获取日期的时间。默认HH:mm:ss格式。失败返回null。 
     * @param date 日期 
     * @return 时间 
     */  
    public static String getTime(Date date) {  
        return DateToString(date, DateStyle.HH_MM_SS);  
    }  

    /** 
     * 获取两个日期相差的天数 
     * @param date 日期字符串 
     * @param otherDate 另一个日期字符串 
     * @return 相差天数 
     */  
    public static int getIntervalDays(String date, String otherDate) {  
        return getIntervalDays(StringToDate(date), StringToDate(otherDate));  
    }  
      
    /** 
     * @param date 日期 
     * @param otherDate 另一个日期 
     * @return 相差天数 
     */  
    public static int getIntervalDays(Date date, Date otherDate) {  
        date = DateUtil.StringToDate(DateUtil.getDate(date));  
        long time = Math.abs(date.getTime() - otherDate.getTime());  
        return (int)time/(24 * 60 * 60 * 1000);  
    }  
} 